import unittest

import requests
from parameterized import parameterized

from api.openAccountApi import OpenAccountApi
from api.rechargeApi import RechargeApi
from api.regLoginApi import RegLoginApi
from api.tenderApi import TenderApi
from common import utils
from common.utils import init_tender_info, html_util


class TestTender(unittest.TestCase):

    @classmethod
    def setUpClass(cls) -> None:
        # 借款标测试数据初始化
        init_tender_info()

    def setUp(self) -> None:
        self.session = requests.session()
        self.reg_login_api = RegLoginApi(self.session)
        self.open_account_api = OpenAccountApi(self.session)
        self.tender_api = TenderApi(self.session)
        self.recharge_api = RechargeApi(self.session)

    def tearDown(self) -> None:
        self.session.close()

    # 投资测试用例
    @parameterized.expand(utils.read_json("test_tender", "tender"))
    def test01_tender(self, keywords, password, id, depositCertificate, amount, exp_status_code, description):
        # 用户登录
        self.reg_login_api.user_login(keywords, password)
        # 投资
        body = {"id": id, "depositCertificate": depositCertificate,
                "amount": amount}
        resp = self.tender_api.tender(body)
        data_json = resp.json()
        print(f'用户登录:{data_json}')
        utils.common_assert(self, resp, exp_status_code, description)

    # 第三方投资测试用例
    def test02_third_tender(self):
        self.reg_login_api.user_login('15814662599', '123456a')
        body = {"id": 642, "depositCertificate": -1,
                "amount": 1000}
        resp = self.tender_api.tender(body)
        url = utils.html_util(resp)[0]
        body = utils.html_util(resp)[1]
        resp = self.tender_api.third_tender(url, body)
        data = resp.text
        print(f'第三方投资: {data}')
        self.assertEqual(200, resp.status_code)
        self.assertIn('OK', data)

    # 投资业务流程
    def test03_tender_process(self):
        # 将使用的数据，设置为变量，方便进行统一管理
        r = 12345
        phone = '15814662555'
        keywords = '15814662555'
        password = '123456a'
        imgVerifyCode = '8888'
        verifycode = '8888'
        valicode = '8888'
        phone_code = '666666'
        exp_status_code = 200
        dy_server = 'on'
        description = '成功'
        # 1.图片验证码接口
        # 通过调用封装的图片验证码接口的方法，获取响应结果
        resp_1 = self.reg_login_api.get_img_verify_code(r)
        # 断言状态码
        self.assertEqual(exp_status_code, resp_1.status_code)

        # 2.获取短信验证码接口
        # 通过调用封装的短信验证码接口的方法，获取响应结果
        resp_2 = self.reg_login_api.get_phone_verify_code(phone, imgVerifyCode, type)
        json_data = resp_2.json()
        print(f'短信验证码: {json_data}')
        # 公共断言
        utils.common_assert(self, resp_2, exp_status_code, description)
        # 3.注册接口
        # 通过调用封装的注册接口的方法，获取响应结果
        resp_3 = self.reg_login_api.user_register(phone, password, verifycode, phone_code, dy_server)
        json_data = resp_3.json()
        print(f'注册: {json_data}')
        # 断言-通用断言
        utils.common_assert(self, resp_3, exp_status_code, description)
        # 4.登录接口
        # 通过调用封装的登录接口的方法，获取响应结果
        # 断言-通用断言
        resp_4 = self.reg_login_api.user_login(keywords, password)
        json_data = resp_4.json()
        print(f'登录: {json_data}')
        # self.assertEqual(200, resp.status_code)
        # self.assertIn('成功', json_data.get('description'))
        # 公共断言
        utils.common_assert(self, resp_4, exp_status_code, description)
        # 5.实名认证接口
        # 通过调用封装的实名认证接口的方法，获取响应结果
        resp_5 = self.open_account_api.realname("张三", "	110101199003074098")
        data_json = resp_5.json()
        print(f'实名认证:{data_json}')
        # 公共断言
        utils.common_assert(self, resp_5, exp_status_code, description)
        # 实名认证信息断言
        self.assertIn('110****098', data_json.get('data').get('card_id'))
        self.assertIn('张*', data_json.get('data').get('realname'))
        # 6.开户接口
        # 通过调用封装的开户接口的方法，获取响应结果
        resp_6 = self.open_account_api.open_account()
        data_json = resp_6.json()
        print(f'实名认证:{data_json}')
        # 断言
        utils.common_assert(self, resp_6, exp_status_code, 'form')
        # 7.第三方开户接口
        # 通过调用封装的获取第三方接口请求数据的方法，获取第三方开户接口的url和请求体数据
        url = html_util(resp_6)[0]
        info = html_util(resp_6)[1]
        # 通过调用封装的第三方开户接口的方法，传入url和请求体数据，获取响应结果
        resp_7 = self.open_account_api.third_open_account(url, info)
        data_text = resp_7.text
        print(data_text)
        # 断言状态码
        self.assertEqual(exp_status_code, resp_7.status_code)
        # 断言响应体数据
        self.assertIn('OK', data_text)

        # 8.获取充值验证码接口
        # 获取充值图片验证码
        resp_8 = self.recharge_api.get_recharge_verify_code(r)
        # 断言
        self.assertEqual(exp_status_code, resp_8.status_code)

        # 9.充值接口
        # 通过调用封装的充值接口的方法，获取响应结果
        body = {"paymentType": "chinapnrTrust", "amount": "100000", "formStr": "formStr", "valicode": valicode}
        resp_9 = self.recharge_api.recharge(body)
        data_json = resp_9.json()
        print(f'充值: {data_json}')
        # 断言
        utils.common_assert(self, resp_9, exp_status_code, "form")
        # 10.第三方充值接口
        # 获取第三方开户接口的url
        url = html_util(resp_9)[0]
        # 获取第三方开户接口的请求体数据
        body = html_util(resp_9)[1]
        # 获取第三方接口返回的响应结果
        resp_10 = self.recharge_api.third_recharge(url, body)
        data_text = resp_10.text
        print(f'第三方充值: {data_text}')
        # 断言
        self.assertEqual(exp_status_code, resp_10.status_code)
        self.assertIn('OK', data_text)

        # 11.投资接口
        # 通过调用封装的投资接口的方法，获取响应结果
        body = {"id": 642, "depositCertificate": -1,
                "amount": 500}
        resp_11 = self.tender_api.tender(body)
        data_json = resp_11.json()
        print(f'用户登录:{data_json}')
        # 断言-通用断言
        utils.common_assert(self, resp_11, exp_status_code, "form")
        # 12.第三方投资接口
        # 通过调用封装的获取第三方接口请求数据的方法，获取第三方开户接口的url和请求体数据
        url = utils.html_util(resp_11)[0]
        body = utils.html_util(resp_11)[1]
        # 通过调用封装的第三方投资接口的方法，传入url和请求体数据，获取响应结果
        resp_12 = self.tender_api.third_tender(url, body)
        data = resp_12.text
        print(f'第三方投资: {data}')
        # 断言状态码
        self.assertEqual(exp_status_code, resp_12.status_code)
        # 断言响应体数据
        self.assertIn('OK', data)
